Classes and Methods גרא וייס המחלקה למדעי המחשב אוניברסיטת בן-גוריון

Size: px

Start display at page:

Download "Classes and Methods גרא וייס המחלקה למדעי המחשב אוניברסיטת בן-גוריון"

Earl Anderson
6 years ago
Views:

1 Classes and Methods גרא וייס המחלקה למדעי המחשב אוניברסיטת בן-גוריון

2 2 Roadmap Lectures 4 and 5 present two sides of OOP: Lecture 4 discusses the static, compile time representation of object-oriented programs Lecture 5 discusses the dynamic, run time behavior Both are important, and both should be understood before we begin further investigation of object-oriented programming

3 3 Objects as Examples of Abstract Data Types We noted that object-oriented programming, and objects in particular, can be viewed from many perspectives We described the many levels of abstraction from which one could examine a program In this chapter, we wish to view objects as examples of abstract data types

of which can be viewed as having two faces: push pop top const limit=300; var currenttop : 0.. limit; values : array [ 1.

4 4 Encapsulation Programming that makes use of data abstractions is a methodological approach to problem solving where information is consciously hidden in a small parts of a program In particular, the programmer develops a series of abstract data types, each of which can be viewed as having two faces: push pop top const limit=300; var currenttop : 0.. limit; values : array [ 1.. limit ] of integer; The outside, or service view, describes what an object does The inside, or implementation view, describes how it does it

5 5 Same Ideas, Different Terms All OOP languages have the following concepts, although the terms they use may differ: Classes, object type, factory object Instances, objects Message passing, method lookup, member function invocation, method binding Methods, member function, method function Inheritance, subclassing

6 6 Encapsulation and Instantiation Classes provide a number of very important capabilities: Encapsulation - The purposeful hiding of information, thereby reducing the amount of details that need to be communicated among programmers A Service View - The ability to characterize an object by the service it provides, without knowing how it performs its task Instantiation - The ability to create multiple instances of an abstraction

7 7 Instances and Instance Variables We have been using the term instance to mean a representative, or example, of a class We will accordingly use the term instance variable to mean an internal variable maintained by an instance Other terms we will occasionally use are data field, or data members Each instance has its own collection of instance variables These values should not be changed directly by clients, but rather should be changed only by methods associated with the class

8 8 Behavior and State An object can be viewed as a combination of behavior and state: Behavior: The actions that an instance can perform in response to a request Implemented by methods State: The data that an object must maintain in order to successfully complete its behavior Stored in instance variables (also known as data members, or data fields)

9 9 Class Definitions We will use as a running example the class definition for a playing card abstraction, and show how this appears in several languages Languages we will consider include Java, C++, C#, Delphi Pascal, Apple Pascal, Ruby, Python, Eiffel, Objective-C and Smalltalk

10 10 Class Definition class PlayingCard { public: enum Suits {Spade, Diamond, Club, Heart; Suits suit () { return suitvalue; int rank () { return rankvalue; ; private: Suits suitvalue; int rankvalue; C++ class PlayingCard { Java public static final int Spade = 1; public static final int Diamond = 2; public static final int Club = 3; public static final int Heart = 4; public int suit () { return suitvalue; public int rank () { return rankvalue; private int suitvalue; private int rankvalue; enum Suits {Spade, Diamond, Club, Heart; class PlayingCard { public Suits suit () { return suitvalue; public int rank () { return rankvalue; private Suits suitvalue; private int rankvalue; C#

11 11 A Typical Example, Class Definition in C++ class PlayingCard { C++ public: enum Suits {Spade, Diamond, Club, Heart; Suits suit () { return suitvalue; int rank () { return rankvalue; private: Suits suitvalue; int rankvalue; ; Note syntax for methods, instance variables, and visibility modifiers

12 12 Visibility Modifiers The terms public and private are used to differentiate the internal and external aspects of a class: Public features can be seen and manipulated by anybody They are the external (interface or service) view Private features can be manipulated only within a class They are the internal (implementation) view Typically methods are public and data fields are private, but either can be placed in either category

13 13 A C# Class Definition enum Suits {Spade, Diamond, Club, Heart; C# class PlayingCard { public Suits suit () { return suitvalue; public int rank () { return rankvalue; private Suits suitvalue; private int rankvalue; C# class definitions have minor differences: no semicolon at end enum cannot be nested inside class, and visibility modifiers are applied to methods and data fields individually

14 14 Java Class Definition class PlayingCard { public int suit () { return suitvalue; public int rank () { return rankvalue; private int suitvalue; private int rankvalue; public static final int Spade = 1; public static final int Diamond = 2; public static final int Club = 3; public static final int Heart = 4; Java also applies visibility modifiers to each item individually. Does not have enumerated data types, uses symbolic constants instead Note the essential difference between the data fields suitvalue and rankvalue and the constants Heart, Spade, Diamond and Club Because the latter are declared as static they exist outside of any one instance of the class, and are shared by all instances The suit and rank fields, on the other hand, are not static and hence each instance of the class will have their own copy of these values

15 15 Static and Final Notice how symbolic constants are defined in Java: static means that all instance share the same value. One per class. Similar meaning in many languages final is Java specific, and means it will not be reassigned. (C++ has const keyword that is similar, although not exactly the same) public static final int Spade = 1; public static final int Diamond = 2; public static final int Club = 3; public static final int Heart = 4;

Niklaus Wirth As a small and efficient language intended to

16 16 Pascal Pascal is an influential imperative and procedural programming language Designed in 1968/9 and published in 1970 by Niklaus Wirth As a small and efficient language intended to encourage good programming practices using structured programming and data structuring

17 17 Pascal Dialects We will consider two dialects of Pascal, both descended from the earlier language. Apple Object Pascal: Defined by Apple Computer, once widely used on the Macintosh, now much less commonly used Delphi Pascal: Defined by Borland on the PC, still fairly widely used on that platform. (Called Kylix on the Linux platform) Many similarities due to the common heritage, but some notable differences. We consider only the language aspects of Delphi, there are many other features related to its visual interface that we will not describe

18 18 Class Definition in Apple Object Pascal type Suits = (Heart, Club, Diamond, Spade); PlayingCard = object suit : Suits; rand : integer; end; No explicit visibility modifiers (We ll later see syntax for methods)

19 19 Delphi Pascal type Suits = (Heart, Club, Diamond, Spade); TPlayingCard = class (TObject) public constructor Create (r : integer; s : Suits); function suit : Suits; function rank : int; private suitvalue : Suits; rankvalue : integer; end; Slightly different syntax, must name parent class, has visibility modifiers and constructors (more on those later)

20 20 Smalltalk Smalltalk doesn't have a textual description for classes, but instead you define classes in a visual interface Revolutionary idea in 1980, but now Visual Basic and Delphi programmers are used to similar facilities

21 21 Methods In the next revision of our playing card abstraction we make the following changes: We add a method that will return the face color of the card, either red or black We add a data field to maintain whether the card is face up or face down, and methods both to test the state of this value and to flip the card

22 22 Methods Although syntax will differ depending upon language, all methods have the following: A name that will be matched to a message to determine when the method should be executed A signature, which is the combination of return type and argument types. Methods with the same name can be distinguished by different signatures A body, which is the code that will be executed when the method is invoked in response to a message

23 23 An Example, from C# class PlayingCard { // constructor, initialize new playing card public PlayingCard (Suits is, int ir) { suit = is; rank = ir; faceup = true; // operations on a playing card public boolean isfaceup () { return faceup; public int rank () { return rankvalue; public Suits suit () { return suitvalue; public void setfaceup (boolean up) { faceup = up; public void flip () { setfaceup(!faceup); public Color color () { if ((suit() == Suits.Diamond) (suit() == Suits.Heart)) return Color.Red; return Color.Black; // private data values private Suits suitvalue; private int rankvalue; private boolean faceup;

24 24 Constructor class PlayingCard { // constructor, initialize new playing card public PlayingCard (Suits is, int ir) { suit = is; rank = ir; faceup = true;... A constructor is a method that is used to initialize a newly constructed object In C++, Java, C# and many other languages it has the same name as the class We will talk about constructors more in the next chapter

25 25 Accessor (or getter) Methods An accessor (or getter) is a method that simply returns an internal data value: class PlayingCard {... // operations on a playing card public int rank () { return rankvalue; public Suits suit () { return suitvalue;... private int rankvalue;

26 26 Why Use an Accessor? There are many reasons why an accessor is preferable to providing direct access to a data field: You can make the data field read-only It provides better documentation that the data field is accessible It makes it easier to later change the access behavior (e.g., count number of accesses) Some conventions encourage the use of a name that begins with get, (as in getrank()), but this is not universally followed

27 27 Setters (or mutators) A setter (sometimes called a mutator method) is a method that is used to change the state of an object: class PlayingCard { // operations on a playing card public void setfaceup (boolean up) { faceup = up;... // private data values private boolean faceup; Mutators are less common than accessors, but reasons for using are similar

28 28 Order of Methods For the most part, languages don't care about the order that methods are declared. Here are some guidelines: List important topics first. Constructors are generally very important, list them first Put public features before private ones Break long lists into groups List items in alphabetical order to make it easier to search Remember that class definitions will often be read by people other than the original programmer Remember the reader, and make it easy for them

29 29 Constant Data Fields Some languages allow data fields to be declared as constant (const modifier in C++, final in Java, other languages have other conventions). Constant data fields can be declared as public, since they cannot be changed. class PlayingCard { // Java example... public static final int Spade = 1; public static final int Diamond = 2; public static final int Club = 3; public static final int Heart = 4;

30 30 Separation of Definition and Implementation In some languages (such as C++ or Object Pascal) the definition of a method can be separated from its implementation. They may even be in a different file: class PlayingCard { public:... Colors color () ;... ; PlayingCard::Colors PlayingCard::color ( ) { // return the face color of a playing card if ((suit == Diamond) (suit == Heart)) return Red; else return Black; Notice need for fully-qualified names.

31 31 Considerations in Method Definitions In C++ you have a choice to define a method in the class interface, or separately in an implementation file. How do you decide? Readability Only put very small methods in the class definition, so that it is easier to read Semantics Methods defined in class interface may (at the discretion of the compiler) be expanded in-line Another reason for only defining very small methods this way.

32 32 Variations on Classes We will consider a few of the mostly languagespecific variations on the idea of a class: Methods without classes in Oberon Methods without Implementations -- interfaces in Java Properties in Delphi and C# Nested classes in Java and C++ Class Data fields

33 33 Methods without Classes in Oberon Oberon does not have classes, per se, but allows methods to be defined as a funny type of function: TYPE PlayingCard = POINTER TO PlayingCardDesc; PlayingCardDesc = RECORD suit : INTEGER; rank : INTEGER; faceup: BOOLEAN; END PROCEDURE (acard: PlayingCard) setfaceup (b : BOOLEAN); BEGIN acard.faceup = b; END

34 34 Interfaces in Java An interface is like a class, but it provides no implementation. Later, another class can declare that it supports the interface, and it must then give an implementation. public interface Storing { void writeout (Stream s); void readfrom (Stream s); ; public class BitImage implements Storing { void writeout (Stream s) {... void readfrom (Stream s) {... ; We will have much more to say about interfaces later after we discuss inheritance

35 35 Properties A property is manipulated syntactically in the fashion of a data field, but operates internally like a method That is, a property can be read as an expression, or assigned to as a value: writeln ('rank is ', acard.rank); (* rank is property of card *) acard.rank= 5; (* changing the rank property *) However, in both cases the value assigned or set will be mediated by a function, rather than a simple data value Properties are a way to define getters and setters, but allow them to be used as if they were simple assignments and expressions

36 36 Properties in Delphi type TPlayingcard = class (TObject) public... property rank : Integer read rankvalue; property suit : Suits read suitvalue write suitvalue; end; private rankvalue : Integer; suitvalue : Suits; Here we have made rank read only, but allowed suit to be both read and written It is also possible to make a property write-only, although this is not very common

37 37 Properties in C# public class PlayingCard { public int rank { get { return rankvalue; set { rankvalue = value;... private int rankvalue; Omitting a set makes it read-only, omitting a get makes it write-only

38 38 Inner or Nested Classes Some languages (C++ or Java) allow a class definition to be given inside another class definition Whether the inner class can access features of the outer class is different in different languages class LinkedList {... private class Link { // inner class public int value; public Link next;

39 39 Class Data Fields Idea is that all instances of a class can share a common data field Simple idea, but how to resolve the following paradox. All instances have the same behavior: Either they all initialize the common area, which seems bad, or Nobody initializes the common area, which is also bad Different languages use a variety of mechanisms to get around this

40 40 Static modifier Class CountingClass { CountingClass () { count = count + 1; // increment count private static int count; // shared by all static { // static block count = 0;

41 41 Chapter Summary In this chapter we have examined the static, or compile time features of classes: The syntax used for class definition The meaning of visibility modifiers (public and private) The syntax used for method definition Accessor or getter methods, and mutator or setter methods Variations on class themes Oberon (methods without classes) Interfaces Properties Nested classes Class data fields

Classes and Methods לאוניד ברנבוים המחלקה למדעי המחשב אוניברסיטת בן-גוריון

Classes and Methods לאוניד ברנבוים המחלקה למדעי המחשב אוניברסיטת בן-גוריון 22 Roadmap Lectures 4 and 5 present two sides of OOP: Lecture 4 discusses the static, compile time representation of object-oriented